import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class Main {

    class MyStack {
        private Queue<Integer> queue1;
        private Queue<Integer> queue2;

        public MyStack() {
            queue1 = new LinkedList<>();
            queue2 = new LinkedList<>();
        }

        public void push(int x) {
            queue1.add(x);
        }

        public int pop() {
            while (queue1.size() > 1) {
                queue2.add(queue1.poll());
            }

            int top = queue1.poll();

            Queue<Integer> temp = queue1;
            queue1 = queue2;
            queue2 = temp;

            return top;
        }

        public int top() {
            int top = pop();
            push(top);
            return top;
        }

        public boolean empty() {
            return queue1.isEmpty();
        }
    }

    class MyQueue {
        private Stack<Integer> inStack;
        private Stack<Integer> outStack;

        public MyQueue() {
            inStack = new Stack<>();
            outStack = new Stack<>();
        }

        public void push(int x) {
            inStack.push(x);
        }

        public int pop() {
            transferElements();
            return outStack.pop();
        }

        public int peek() {
            transferElements();
            return outStack.peek();
        }

        public boolean empty() {
            return inStack.isEmpty() && outStack.isEmpty();
        }

        private void transferElements() {
            if (outStack.isEmpty()) {
                while (!inStack.isEmpty()) {
                    outStack.push(inStack.pop());
                }
            }
        }
    }

    class MyCircularQueue {
        private int[] data;
        private int front;
        private int rear;
        private int size;
        private int capacity;

        public MyCircularQueue(int k) {
            capacity = k;
            data = new int[capacity];
            front = 0;
            rear = -1;
            size = 0;
        }

        public boolean enQueue(int value) {
            if (isFull()) {
                return false;
            }
            rear = (rear + 1) % capacity;
            data[rear] = value;
            size++;
            return true;
        }

        public boolean deQueue() {
            if (isEmpty()) {
                return false;
            }
            front = (front + 1) % capacity;
            size--;
            return true;
        }

        public int Front() {
            if (isEmpty()) {
                return -1;
            }
            return data[front];
        }

        public int Rear() {
            if (isEmpty()) {
                return -1;
            }
            return data[rear];
        }

        public boolean isEmpty() {
            return size == 0;
        }

        public boolean isFull() {
            return size == capacity;
        }
    }

    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}